Client/server computing has become more and more important over the past few years in the information technology world. This type of distributed computing allows one machine to delegate some of its work to another machine that might be, for example, better suited to perform that work.
The benefits of client/server computing have been even further enhanced by the use of a well-known computer programming technology called object-oriented programming (OOP), which allows the client and server to be located on different (heterogeneous) "platforms". A platform is a combination of the specific hardware/software/operating system/communication protocol which a machine uses to do its work. OOP allows the client application program and server application program to operate on their own platforms without worrying about how the client application's work requests will be communicated to and accepted by the server application. Likewise, the server application does not have to worry about how the OOP system will receive, translate and send the server application's processing results back to the requesting client application.
Details of how OOP techniques have been integrated with heterogeneous client/server systems are explained in U.S. Pat. No. 5,440,744 and European Patent Application 0 677,943 A2. These latter two publications are hereby incorporated by reference. However, an example, of the basic architecture will be given below for contextual understanding of the invention's environment.
As shown in FIG. 1, the client computer 10 (which could, for example, be a personal computer having the IBM OS/2 operating system installed thereon) has an application program 40 running on its operating system ("IBM" and "OS/2" are trademarks of the International Business Machines Corporation). The application program 40 will periodically require work to be performed on the server computer 20 and/or data to be returned from the server 20 for subsequent use by the application program 40. The server computer 20 can be, for example, a high-powered mainframe computer running on IBM's MVS operating system ("MVS" is also a trademark of the IBM Corp.).
When the client computer 10 wishes to make a request for the server computer 20's services, the first application program 40 informs the first logic means 50 of the service required. It may, for example, do this by sending the first logic means the name of a remote procedure along with a list of input and output parameters. The first logic means 50 then handles the task of establishing the necessary communications with the second computer 20 with reference to definitions of the available communications services stored in the storage device 60. All the possible services are defined as a cohesive framework of object classes 70, these classes being derived from a single object class. Defining the services in this way gives rise to a great number of advantages in terms of performance and reusability.
To establish the necessary communication with the server 20, the first logic means 50 determines which object class in the framework needs to be used, and then creates an instance of that object on the server 20, a message being sent to that object so as to cause that object to invoke one of its methods. This gives rise to the establishment of the connection with the server computer 20 via the connection means 80, and the subsequent sending of a request to the second logic means 90.
The second logic means 90 then passes the request on to the second application program 100 (hereafter called the service application) running on the server computer 20 so that the service application 100 can perform the specific task required by that request, such as running a data retrieval procedure. Once this task has been completed the service application may need to send results back to the first computer 10. The server application 100 interacts with the second logic means 90 during the performance of the requested tasks and when results are to be sent back to the first computer 10. The second logic means 90 establishes instances of objects, and invokes appropriate methods of those objects, as and when required by the server application 100, the object instances being created from the cohesive framework of object classes stored in the storage device 110.
Using the above technique, the client application program 40 is not exposed to the communications architecture. Further the service application 100 is invoked through the standard mechanism for its environment; it does not know that it is being invoked remotely.
The Object Management Group (OMG) is an international consortium of organizations involved in various aspects of client/server computing on heterogeneous platforms with distributed objects. The OMG has set forth published standards by which client computers (e.g. 10) communicate (in OOP form) with server machines (e.g. 20). As part of these standards, an Object Request Broker has been defined, which provides the object-oriented bridge between the client and the server machines. The ORB decouples the client and server applications from the object oriented implementation details, performing at least part of the work of the first and second logic means 50 and 90 as well as the connection means 80.
Once client requests find their way through the ORB and into the server computer 20, the ORB finds a particular server object capable of executing the request and sends the request to that server object's Object Adapter (also defined by OMG standard) where it is stored in the Object Adapter's queue (buffer) to await processing by the server object. The buffer is a First-In-First-Out queue, meaning that the first request received in the buffer at one end thereof is the first to leave out the other end. The server object has a plurality of parallel "execution threads" upon any of which it can run an instance of itself. In this way, the server object is able to process similar requests from different clients at the same time. The Object Adapter looks to see which of the parallel execution threads is ready to process another request and assigns the request located at the end of the buffer to the next available execution thread. This is explained in the abovementioned U.S. patent as a "dispatching" mechanism whereby the server dispatches queued requests to execution threads.
This architecture has worked fine for instances where a client computer 10 wishes a server computer 20 to perform a "one-shot" work item (meaning the client computer will probably not require that particular server to do further work after the server returns the processing result). Since there is no need for a relationship to exist between the various client requests stored in a particular server's FIFO buffer, the next available execution thread can simply be given the next output of the buffer.
However, there are other client/server applications which are not "one-shot" in nature and require a continued relationship between a particular client machine 10 and a particular server machine 20. An example of such applications is the processing of "transactions".
Computer implemented transaction processing systems are used for critical business tasks in a number of industries. A transaction defines a single unit of work that must either be fully completed or fully purged without action. For example, in the case of a bank automated teller machine from which a customer seeks to withdraw money, the actions of issuing the money, reducing the balance of money on hand in the machine and reducing the customer's bank balance must all occur or none of them must occur. Failure of one of the subordinate actions would lead to inconsistency between the records and the actual occurrences.
Distributed transaction processing involves a transaction that affects resources at more than one physical or logical location. In the above example, a transaction affects resources managed at the local automated teller device as well as bank balances managed by a bank's main computer. Such transactions involve one particular client computer (e.g. 10) communicating with one particular server computer (e.g. 20) over a series of client requests which are processed by the server.
If the client and server machines are located on heterogeneous platforms, the object-oriented architecture of FIG. 1 could be used as the distributed processing environment. However, the standard OMG Object Adapter/Object Request Broker architecture using the FIFO buffer and sending the oldest stored request to the next available execution thread within the server will not give good results. If two transactionally related requests are processed by different execution threads of the server, the execution environment for each request will be different and consistent overall results can thus not be achieved. The results of the first executed request will not be made available while processing a next executed request which is part of the same transaction. For example, these two requests could be being processed simultaneously by two different execution threads within the server.
This problem has greatly dissuaded the use of heterogeneous client/server systems to process distributed transactions (and other processing contexts in which related requests are involved), leaving such distributed transactions to be processed on homogeneous client/server architectures (such as computer terminals accessing host mainframe computers) so that a consistent execution environment is provided to produce guaranteed results.